// config.h
/* See LICENSE file for copyright and license details. */
/* Default settings; can be overriden by command line. */

static int topbar = 0; /* -b  option; if 0, dmenu appears at bottom     */
/* -fn option overrides fonts[0]; default X11 font or font set */
static const char *fonts[] = {
    "monospace:size=10"};
static const char *prompt = NULL; /* -p  option; prompt to the left of input field */
static const char *colors[SchemeLast][2] = {
    /*     fg         bg       */
    [SchemeNorm] = {"#bbbbbb", "#222222"},
    [SchemeSel] = {"#eeeeee", "#005577"},
    [SchemeOut] = {"#000000", "#00ffff"},
};
/* -l option; if nonzero, dmenu uses vertical list with given number of lines */
static unsigned int lines = 0;

/*
 * Characters not considered part of a word while deleting words
 * for example: " /?\"&[]"
 */
static const char worddelimiters[] = " ";
/*
 * Copy me if you can.
 * by 20h
 */

#ifndef ARG_H__
#define ARG_H__

extern char *argv0;

/* use main(int argc, char *argv[]) */
#define ARGBEGIN                                     \
    for (argv0 = *argv, argv++, argc--;              \
         argv[0] && argv[0][0] == '-' && argv[0][1]; \
         argc--, argv++)                             \
    {                                                \
        char argc_;                                  \
        char **argv_;                                \
        int brk_;                                    \
        if (argv[0][1] == '-' && argv[0][2] == '\0') \
        {                                            \
            argv++;                                  \
            argc--;                                  \
            break;                                   \
        }                                            \
        for (brk_ = 0, argv[0]++, argv_ = argv;      \
             argv[0][0] && !brk_;                    \
             argv[0]++)                              \
        {                                            \
            if (argv_ != argv)                       \
                break;                               \
            argc_ = argv[0][0];                      \
            switch (argc_)

#define ARGEND \
    }          \
    }

#define ARGC() argc_

#define EARGF(x) ((argv[0][1] == '\0' && argv[1] == NULL) ? ((x), abort(), (char *)0) : (brk_ = 1, (argv[0][1] != '\0') ? (&argv[0][1]) : (argc--, argv++, argv[0])))

#define ARGF() ((argv[0][1] == '\0' && argv[1] == NULL) ? (char *)0 : (brk_ = 1, (argv[0][1] != '\0') ? (&argv[0][1]) : (argc--, argv++, argv[0])))

#endif

// dmenu.c
/* See LICENSE file for copyright and license details. */
#include <ctype.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <time.h>
#include <unistd.h>

#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#ifdef XINERAMA
#include <X11/extensions/Xinerama.h>
#endif
#include <X11/Xft/Xft.h>

#include "drw.h"
#include "util.h"

/* macros */
#define INTERSECT(x, y, w, h, r) (MAX(0, MIN((x) + (w), (r).x_org + (r).width) - MAX((x), (r).x_org)) * MAX(0, MIN((y) + (h), (r).y_org + (r).height) - MAX((y), (r).y_org)))
#define TEXTW(X) (drw_fontset_getwidth(drw, (X)) + lrpad)

/* enums */
enum
{
    SchemeNorm,
    SchemeSel,
    SchemeOut,
    SchemeLast
}; /* color schemes */

struct item
{
    char *text;
    struct item *left, *right;
    int out;
};

static char text[BUFSIZ] = "";
static char *embed;
static int bh, mw, mh;
static int inputw = 0, promptw;
static int lrpad; /* sum of left and right padding */
static size_t cursor;
static struct item *items = NULL;
static struct item *matches, *matchend;
static struct item *prev, *curr, *next, *sel;
static int mon = -1, screen;

static Atom clip, utf8;
static Display *dpy;
static Window root, parentwin, win;
static XIC xic;

static Drw *drw;
static Clr *scheme[SchemeLast];

#include "config.h"

static int (*fstrncmp)(const char *, const char *, size_t) = strncmp;
static char *(*fstrstr)(const char *, const char *) = strstr;

static unsigned int
textw_clamp(const char *str, unsigned int n)
{
    unsigned int w = drw_fontset_getwidth_clamp(drw, str, n) + lrpad;
    return MIN(w, n);
}

static void
appenditem(struct item *item, struct item **list, struct item **last)
{
    if (*last)
        (*last)->right = item;
    else
        *list = item;

    item->left = *last;
    item->right = NULL;
    *last = item;
}

static void
calcoffsets(void)
{
    int i, n;

    if (lines > 0)
        n = lines * bh;
    else
        n = mw - (promptw + inputw + TEXTW("<") + TEXTW(">"));
    /* calculate which items will begin the next page and previous page */
    for (i = 0, next = curr; next; next = next->right)
        if ((i += (lines > 0) ? bh : textw_clamp(next->text, n)) > n)
            break;
    for (i = 0, prev = curr; prev && prev->left; prev = prev->left)
        if ((i += (lines > 0) ? bh : textw_clamp(prev->left->text, n)) > n)
            break;
}

static void
cleanup(void)
{
    size_t i;

    XUngrabKeyboard(dpy, CurrentTime);
    for (i = 0; i < SchemeLast; i++)
        free(scheme[i]);
    for (i = 0; items && items[i].text; ++i)
        free(items[i].text);
    free(items);
    drw_free(drw);
    XSync(dpy, False);
    XCloseDisplay(dpy);
}

static char *
cistrstr(const char *h, const char *n)
{
    size_t i;

    if (!n[0])
        return (char *)h;

    for (; *h; ++h)
    {
        for (i = 0; n[i] && tolower((unsigned char)n[i]) ==
                                tolower((unsigned char)h[i]);
             ++i)
            ;
        if (n[i] == '\0')
            return (char *)h;
    }
    return NULL;
}

static int
drawitem(struct item *item, int x, int y, int w)
{
    if (item == sel)
        drw_setscheme(drw, scheme[SchemeSel]);
    else if (item->out)
        drw_setscheme(drw, scheme[SchemeOut]);
    else
        drw_setscheme(drw, scheme[SchemeNorm]);

    return drw_text(drw, x, y, w, bh, lrpad / 2, item->text, 0);
}

static void
drawmenu(void)
{
    unsigned int curpos;
    struct item *item;
    int x = 0, y = 0, w;

    drw_setscheme(drw, scheme[SchemeNorm]);
    drw_rect(drw, 0, 0, mw, mh, 1, 1);

    if (prompt && *prompt)
    {
        drw_setscheme(drw, scheme[SchemeSel]);
        x = drw_text(drw, x, 0, promptw, bh, lrpad / 2, prompt, 0);
    }
    /* draw input field */
    w = (lines > 0 || !matches) ? mw - x : inputw;
    drw_setscheme(drw, scheme[SchemeNorm]);
    drw_text(drw, x, 0, w, bh, lrpad / 2, text, 0);

    curpos = TEXTW(text) - TEXTW(&text[cursor]);
    if ((curpos += lrpad / 2 - 1) < w)
    {
        drw_setscheme(drw, scheme[SchemeNorm]);
        drw_rect(drw, x + curpos, 2, 2, bh - 4, 1, 0);
    }

    if (lines > 0)
    {
        /* draw vertical list */
        for (item = curr; item != next; item = item->right)
            drawitem(item, x, y += bh, mw - x);
    }
    else if (matches)
    {
        /* draw horizontal list */
        x += inputw;
        w = TEXTW("<");
        if (curr->left)
        {
            drw_setscheme(drw, scheme[SchemeNorm]);
            drw_text(drw, x, 0, w, bh, lrpad / 2, "<", 0);
        }
        x += w;
        for (item = curr; item != next; item = item->right)
            x = drawitem(item, x, 0, textw_clamp(item->text, mw - x - TEXTW(">")));
        if (next)
        {
            w = TEXTW(">");
            drw_setscheme(drw, scheme[SchemeNorm]);
            drw_text(drw, mw - w, 0, w, bh, lrpad / 2, ">", 0);
        }
    }
    drw_map(drw, win, 0, 0, mw, mh);
}

static void
grabfocus(void)
{
    struct timespec ts = {.tv_sec = 0, .tv_nsec = 10000000};
    Window focuswin;
    int i, revertwin;

    for (i = 0; i < 100; ++i)
    {
        XGetInputFocus(dpy, &focuswin, &revertwin);
        if (focuswin == win)
            return;
        XSetInputFocus(dpy, win, RevertToParent, CurrentTime);
        nanosleep(&ts, NULL);
    }
    die("cannot grab focus");
}

static void
grabkeyboard(void)
{
    struct timespec ts = {.tv_sec = 0, .tv_nsec = 1000000};
    int i;

    if (embed)
        return;
    /* try to grab keyboard, we may have to wait for another process to ungrab */
    for (i = 0; i < 1000; i++)
    {
        if (XGrabKeyboard(dpy, DefaultRootWindow(dpy), True, GrabModeAsync,
                          GrabModeAsync, CurrentTime) == GrabSuccess)
            return;
        nanosleep(&ts, NULL);
    }
    die("cannot grab keyboard");
}

static void
match(void)
{
    static char **tokv = NULL;
    static int tokn = 0;

    char buf[sizeof text], *s;
    int i, tokc = 0;
    size_t len, textsize;
    struct item *item, *lprefix, *lsubstr, *prefixend, *substrend;

    strcpy(buf, text);
    /* separate input text into tokens to be matched individually */
    for (s = strtok(buf, " "); s; tokv[tokc - 1] = s, s = strtok(NULL, " "))
        if (++tokc > tokn && !(tokv = realloc(tokv, ++tokn * sizeof *tokv)))
            die("cannot realloc %zu bytes:", tokn * sizeof *tokv);
    len = tokc ? strlen(tokv[0]) : 0;

    matches = lprefix = lsubstr = matchend = prefixend = substrend = NULL;
    textsize = strlen(text) + 1;
    for (item = items; item && item->text; item++)
    {
        for (i = 0; i < tokc; i++)
            if (!fstrstr(item->text, tokv[i]))
                break;
        if (i != tokc) /* not all tokens match */
            continue;
        /* exact matches go first, then prefixes, then substrings */
        if (!tokc || !fstrncmp(text, item->text, textsize))
            appenditem(item, &matches, &matchend);
        else if (!fstrncmp(tokv[0], item->text, len))
            appenditem(item, &lprefix, &prefixend);
        else
            appenditem(item, &lsubstr, &substrend);
    }
    if (lprefix)
    {
        if (matches)
        {
            matchend->right = lprefix;
            lprefix->left = matchend;
        }
        else
            matches = lprefix;
        matchend = prefixend;
    }
    if (lsubstr)
    {
        if (matches)
        {
            matchend->right = lsubstr;
            lsubstr->left = matchend;
        }
        else
            matches = lsubstr;
        matchend = substrend;
    }
    curr = sel = matches;
    calcoffsets();
}

static void
insert(const char *str, ssize_t n)
{
    if (strlen(text) + n > sizeof text - 1)
        return;
    /* move existing text out of the way, insert new text, and update cursor */
    memmove(&text[cursor + n], &text[cursor], sizeof text - cursor - MAX(n, 0));
    if (n > 0)
        memcpy(&text[cursor], str, n);
    cursor += n;
    match();
}

static size_t
nextrune(int inc)
{
    ssize_t n;

    /* return location of next utf8 rune in the given direction (+1 or -1) */
    for (n = cursor + inc; n + inc >= 0 && (text[n] & 0xc0) == 0x80; n += inc)
        ;
    return n;
}

static void
movewordedge(int dir)
{
    if (dir < 0)
    { /* move cursor to the start of the word*/
        while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)]))
            cursor = nextrune(-1);
        while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)]))
            cursor = nextrune(-1);
    }
    else
    { /* move cursor to the end of the word */
        while (text[cursor] && strchr(worddelimiters, text[cursor]))
            cursor = nextrune(+1);
        while (text[cursor] && !strchr(worddelimiters, text[cursor]))
            cursor = nextrune(+1);
    }
}

static void
keypress(XKeyEvent *ev)
{
    char buf[64];
    int len;
    KeySym ksym = NoSymbol;
    Status status;

    len = XmbLookupString(xic, ev, buf, sizeof buf, &ksym, &status);
    switch (status)
    {
    default: /* XLookupNone, XBufferOverflow */
        return;
    case XLookupChars: /* composed string from input method */
        goto insert;
    case XLookupKeySym:
    case XLookupBoth: /* a KeySym and a string are returned: use keysym */
        break;
    }

    if (ev->state & ControlMask)
    {
        switch (ksym)
        {
        case XK_a:
            ksym = XK_Home;
            break;
        case XK_b:
            ksym = XK_Left;
            break;
        case XK_c:
            ksym = XK_Escape;
            break;
        case XK_d:
            ksym = XK_Delete;
            break;
        case XK_e:
            ksym = XK_End;
            break;
        case XK_f:
            ksym = XK_Right;
            break;
        case XK_g:
            ksym = XK_Escape;
            break;
        case XK_h:
            ksym = XK_BackSpace;
            break;
        case XK_i:
            ksym = XK_Tab;
            break;
        case XK_j: /* fallthrough */
        case XK_J: /* fallthrough */
        case XK_m: /* fallthrough */
        case XK_M:
            ksym = XK_Return;
            ev->state &= ~ControlMask;
            break;
        case XK_n:
            ksym = XK_Down;
            break;
        case XK_p:
            ksym = XK_Up;
            break;

        case XK_k: /* delete right */
            text[cursor] = '\0';
            match();
            break;
        case XK_u: /* delete left */
            insert(NULL, 0 - cursor);
            break;
        case XK_w: /* delete word */
            while (cursor > 0 && strchr(worddelimiters, text[nextrune(-1)]))
                insert(NULL, nextrune(-1) - cursor);
            while (cursor > 0 && !strchr(worddelimiters, text[nextrune(-1)]))
                insert(NULL, nextrune(-1) - cursor);
            break;
        case XK_y: /* paste selection */
        case XK_Y:
            XConvertSelection(dpy, (ev->state & ShiftMask) ? clip : XA_PRIMARY,
                              utf8, utf8, win, CurrentTime);
            return;
        case XK_Left:
        case XK_KP_Left:
            movewordedge(-1);
            goto draw;
        case XK_Right:
        case XK_KP_Right:
            movewordedge(+1);
            goto draw;
        case XK_Return:
        case XK_KP_Enter:
            break;
        case XK_bracketleft:
            cleanup();
            exit(1);
        default:
            return;
        }
    }
    else if (ev->state & Mod1Mask)
    {
        switch (ksym)
        {
        case XK_b:
            movewordedge(-1);
            goto draw;
        case XK_f:
            movewordedge(+1);
            goto draw;
        case XK_g:
            ksym = XK_Home;
            break;
        case XK_G:
            ksym = XK_End;
            break;
        case XK_h:
            ksym = XK_Up;
            break;
        case XK_j:
            ksym = XK_Next;
            break;
        case XK_k:
            ksym = XK_Prior;
            break;
        case XK_l:
            ksym = XK_Down;
            break;
        default:
            return;
        }
    }

    switch (ksym)
    {
    default:
    insert:
        if (!iscntrl((unsigned char)*buf))
            insert(buf, len);
        break;
    case XK_Delete:
    case XK_KP_Delete:
        if (text[cursor] == '\0')
            return;
        cursor = nextrune(+1);
        /* fallthrough */
    case XK_BackSpace:
        if (cursor == 0)
            return;
        insert(NULL, nextrune(-1) - cursor);
        break;
    case XK_End:
    case XK_KP_End:
        if (text[cursor] != '\0')
        {
            cursor = strlen(text);
            break;
        }
        if (next)
        {
            /* jump to end of list and position items in reverse */
            curr = matchend;
            calcoffsets();
            curr = prev;
            calcoffsets();
            while (next && (curr = curr->right))
                calcoffsets();
        }
        sel = matchend;
        break;
    case XK_Escape:
        cleanup();
        exit(1);
    case XK_Home:
    case XK_KP_Home:
        if (sel == matches)
        {
            cursor = 0;
            break;
        }
        sel = curr = matches;
        calcoffsets();
        break;
    case XK_Left:
    case XK_KP_Left:
        if (cursor > 0 && (!sel || !sel->left || lines > 0))
        {
            cursor = nextrune(-1);
            break;
        }
        if (lines > 0)
            return;
        /* fallthrough */
    case XK_Up:
    case XK_KP_Up:
        if (sel && sel->left && (sel = sel->left)->right == curr)
        {
            curr = prev;
            calcoffsets();
        }
        break;
    case XK_Next:
    case XK_KP_Next:
        if (!next)
            return;
        sel = curr = next;
        calcoffsets();
        break;
    case XK_Prior:
    case XK_KP_Prior:
        if (!prev)
            return;
        sel = curr = prev;
        calcoffsets();
        break;
    case XK_Return:
    case XK_KP_Enter:
        puts((sel && !(ev->state & ShiftMask)) ? sel->text : text);
        if (!(ev->state & ControlMask))
        {
            cleanup();
            exit(0);
        }
        if (sel)
            sel->out = 1;
        break;
    case XK_Right:
    case XK_KP_Right:
        if (text[cursor] != '\0')
        {
            cursor = nextrune(+1);
            break;
        }
        if (lines > 0)
            return;
        /* fallthrough */
    case XK_Down:
    case XK_KP_Down:
        if (sel && sel->right && (sel = sel->right) == next)
        {
            curr = next;
            calcoffsets();
        }
        break;
    case XK_Tab:
        if (!sel)
            return;
        cursor = strnlen(sel->text, sizeof text - 1);
        memcpy(text, sel->text, cursor);
        text[cursor] = '\0';
        match();
        break;
    }

draw:
    drawmenu();
}

static void
paste(void)
{
    char *p, *q;
    int di;
    unsigned long dl;
    Atom da;

    /* we have been given the current selection, now insert it into input */
    if (XGetWindowProperty(dpy, win, utf8, 0, (sizeof text / 4) + 1, False,
                           utf8, &da, &di, &dl, &dl, (unsigned char **)&p) == Success &&
        p)
    {
        insert(p, (q = strchr(p, '\n')) ? q - p : (ssize_t)strlen(p));
        XFree(p);
    }
    drawmenu();
}

static void
readstdin(void)
{
    char *line = NULL;
    size_t i, itemsiz = 0, linesiz = 0;
    ssize_t len;

    /* read each line from stdin and add it to the item list */
    for (i = 0; (len = getline(&line, &linesiz, stdin)) != -1; i++)
    {
        if (i + 1 >= itemsiz)
        {
            itemsiz += 256;
            if (!(items = realloc(items, itemsiz * sizeof(*items))))
                die("cannot realloc %zu bytes:", itemsiz * sizeof(*items));
        }
        if (line[len - 1] == '\n')
            line[len - 1] = '\0';
        if (!(items[i].text = strdup(line)))
            die("strdup:");

        items[i].out = 0;
    }
    free(line);
    if (items)
        items[i].text = NULL;
    lines = MIN(lines, i);
}

static void
run(void)
{
    XEvent ev;

    while (!XNextEvent(dpy, &ev))
    {
        if (XFilterEvent(&ev, win))
            continue;
        switch (ev.type)
        {
        case DestroyNotify:
            if (ev.xdestroywindow.window != win)
                break;
            cleanup();
            exit(1);
        case Expose:
            if (ev.xexpose.count == 0)
                drw_map(drw, win, 0, 0, mw, mh);
            break;
        case FocusIn:
            /* regrab focus from parent window */
            if (ev.xfocus.window != win)
                grabfocus();
            break;
        case KeyPress:
            keypress(&ev.xkey);
            break;
        case SelectionNotify:
            if (ev.xselection.property == utf8)
                paste();
            break;
        case VisibilityNotify:
            if (ev.xvisibility.state != VisibilityUnobscured)
                XRaiseWindow(dpy, win);
            break;
        }
    }
}

static void
setup(void)
{
    int x, y, i, j;
    unsigned int du;
    XSetWindowAttributes swa;
    XIM xim;
    Window w, dw, *dws;
    XWindowAttributes wa;
    XClassHint ch = {"dmenu", "dmenu"};
#ifdef XINERAMA
    XineramaScreenInfo *info;
    Window pw;
    int a, di, n, area = 0;
#endif
    /* init appearance */
    for (j = 0; j < SchemeLast; j++)
        scheme[j] = drw_scm_create(drw, colors[j], 2);

    clip = XInternAtom(dpy, "CLIPBOARD", False);
    utf8 = XInternAtom(dpy, "UTF8_STRING", False);

    /* calculate menu geometry */
    bh = drw->fonts->h + 2;
    lines = MAX(lines, 0);
    mh = (lines + 1) * bh;
#ifdef XINERAMA
    i = 0;
    if (parentwin == root && (info = XineramaQueryScreens(dpy, &n)))
    {
        XGetInputFocus(dpy, &w, &di);
        if (mon >= 0 && mon < n)
            i = mon;
        else if (w != root && w != PointerRoot && w != None)
        {
            /* find top-level window containing current input focus */
            do
            {
                if (XQueryTree(dpy, (pw = w), &dw, &w, &dws, &du) && dws)
                    XFree(dws);
            } while (w != root && w != pw);
            /* find xinerama screen with which the window intersects most */
            if (XGetWindowAttributes(dpy, pw, &wa))
                for (j = 0; j < n; j++)
                    if ((a = INTERSECT(wa.x, wa.y, wa.width, wa.height, info[j])) > area)
                    {
                        area = a;
                        i = j;
                    }
        }
        /* no focused window is on screen, so use pointer location instead */
        if (mon < 0 && !area && XQueryPointer(dpy, root, &dw, &dw, &x, &y, &di, &di, &du))
            for (i = 0; i < n; i++)
                if (INTERSECT(x, y, 1, 1, info[i]) != 0)
                    break;

        x = info[i].x_org;
        y = info[i].y_org + (topbar ? 0 : info[i].height - mh);
        mw = info[i].width;
        XFree(info);
    }
    else
#endif
    {
        if (!XGetWindowAttributes(dpy, parentwin, &wa))
            die("could not get embedding window attributes: 0x%lx",
                parentwin);
        x = 0;
        y = topbar ? 0 : wa.height - mh;
        mw = wa.width;
    }
    promptw = (prompt && *prompt) ? TEXTW(prompt) - lrpad / 4 : 0;
    inputw = mw / 3; /* input width: ~33% of monitor width */
    match();

    /* create menu window */
    swa.override_redirect = True;
    swa.background_pixel = scheme[SchemeNorm][ColBg].pixel;
    swa.event_mask = ExposureMask | KeyPressMask | VisibilityChangeMask;
    win = XCreateWindow(dpy, root, x, y, mw, mh, 0,
                        CopyFromParent, CopyFromParent, CopyFromParent,
                        CWOverrideRedirect | CWBackPixel | CWEventMask, &swa);
    XSetClassHint(dpy, win, &ch);

    /* input methods */
    if ((xim = XOpenIM(dpy, NULL, NULL, NULL)) == NULL)
        die("XOpenIM failed: could not open input device");

    xic = XCreateIC(xim, XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
                    XNClientWindow, win, XNFocusWindow, win, NULL);

    XMapRaised(dpy, win);
    if (embed)
    {
        XReparentWindow(dpy, win, parentwin, x, y);
        XSelectInput(dpy, parentwin, FocusChangeMask | SubstructureNotifyMask);
        if (XQueryTree(dpy, parentwin, &dw, &w, &dws, &du) && dws)
        {
            for (i = 0; i < du && dws[i] != win; ++i)
                XSelectInput(dpy, dws[i], FocusChangeMask);
            XFree(dws);
        }
        grabfocus();
    }
    drw_resize(drw, mw, mh);
    drawmenu();
}

static void
usage(void)
{
    die("usage: dmenu [-bfiv] [-l lines] [-p prompt] [-fn font] [-m monitor]\n"
        "             [-nb color] [-nf color] [-sb color] [-sf color] [-w windowid]");
}

int main(int argc, char *argv[])
{
    XWindowAttributes wa;
    int i, fast = 0;

    for (i = 1; i < argc; i++)
        /* these options take no arguments */
        if (!strcmp(argv[i], "-v"))
        { /* prints version information */
            puts("dmenu-" VERSION);
            exit(0);
        }
        else if (!strcmp(argv[i], "-b")) /* appears at the bottom of the screen */
            topbar = 0;
        else if (!strcmp(argv[i], "-f")) /* grabs keyboard before reading stdin */
            fast = 1;
        else if (!strcmp(argv[i], "-i"))
        { /* case-insensitive item matching */
            fstrncmp = strncasecmp;
            fstrstr = cistrstr;
        }
        else if (i + 1 == argc)
            usage();
        /* these options take one argument */
        else if (!strcmp(argv[i], "-l")) /* number of lines in vertical list */
            lines = atoi(argv[++i]);
        else if (!strcmp(argv[i], "-m"))
            mon = atoi(argv[++i]);
        else if (!strcmp(argv[i], "-p")) /* adds prompt to left of input field */
            prompt = argv[++i];
        else if (!strcmp(argv[i], "-fn")) /* font or font set */
            fonts[0] = argv[++i];
        else if (!strcmp(argv[i], "-nb")) /* normal background color */
            colors[SchemeNorm][ColBg] = argv[++i];
        else if (!strcmp(argv[i], "-nf")) /* normal foreground color */
            colors[SchemeNorm][ColFg] = argv[++i];
        else if (!strcmp(argv[i], "-sb")) /* selected background color */
            colors[SchemeSel][ColBg] = argv[++i];
        else if (!strcmp(argv[i], "-sf")) /* selected foreground color */
            colors[SchemeSel][ColFg] = argv[++i];
        else if (!strcmp(argv[i], "-w")) /* embedding window id */
            embed = argv[++i];
        else
            usage();

    if (!setlocale(LC_CTYPE, "") || !XSupportsLocale())
        fputs("warning: no locale support\n", stderr);
    if (!(dpy = XOpenDisplay(NULL)))
        die("cannot open display");
    screen = DefaultScreen(dpy);
    root = RootWindow(dpy, screen);
    if (!embed || !(parentwin = strtol(embed, NULL, 0)))
        parentwin = root;
    if (!XGetWindowAttributes(dpy, parentwin, &wa))
        die("could not get embedding window attributes: 0x%lx",
            parentwin);
    drw = drw_create(dpy, screen, root, wa.width, wa.height);
    if (!drw_fontset_create(drw, fonts, LENGTH(fonts)))
        die("no fonts could be loaded.");
    lrpad = drw->fonts->h;

#ifdef __OpenBSD__
    if (pledge("stdio rpath", NULL) == -1)
        die("pledge");
#endif

    if (fast && !isatty(0))
    {
        grabkeyboard();
        readstdin();
    }
    else
    {
        readstdin();
        grabkeyboard();
    }
    setup();
    run();

    return 1; /* unreachable */
}

// drw.c
/* See LICENSE file for copyright and license details. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <X11/Xlib.h>
#include <X11/Xft/Xft.h>

#include "drw.h"
#include "util.h"

#define UTF_INVALID 0xFFFD

static int
utf8decode(const char *s_in, long *u, int *err)
{
    static const unsigned char lens[] = {
        /* 0XXXX */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
        /* 10XXX */ 0, 0, 0, 0, 0, 0, 0, 0, /* invalid */
        /* 110XX */ 2, 2, 2, 2,
        /* 1110X */ 3, 3,
        /* 11110 */ 4,
        /* 11111 */ 0, /* invalid */
    };
    static const unsigned char leading_mask[] = {0x7F, 0x1F, 0x0F, 0x07};
    static const unsigned int overlong[] = {0x0, 0x80, 0x0800, 0x10000};

    const unsigned char *s = (const unsigned char *)s_in;
    int len = lens[*s >> 3];
    *u = UTF_INVALID;
    *err = 1;
    if (len == 0)
        return 1;

    long cp = s[0] & leading_mask[len - 1];
    for (int i = 1; i < len; ++i)
    {
        if (s[i] == '\0' || (s[i] & 0xC0) != 0x80)
            return i;
        cp = (cp << 6) | (s[i] & 0x3F);
    }
    /* out of range, surrogate, overlong encoding */
    if (cp > 0x10FFFF || (cp >> 11) == 0x1B || cp < overlong[len - 1])
        return len;

    *err = 0;
    *u = cp;
    return len;
}

Drw *drw_create(Display *dpy, int screen, Window root, unsigned int w, unsigned int h)
{
    Drw *drw = ecalloc(1, sizeof(Drw));

    drw->dpy = dpy;
    drw->screen = screen;
    drw->root = root;
    drw->w = w;
    drw->h = h;
    drw->drawable = XCreatePixmap(dpy, root, w, h, DefaultDepth(dpy, screen));
    drw->gc = XCreateGC(dpy, root, 0, NULL);
    XSetLineAttributes(dpy, drw->gc, 1, LineSolid, CapButt, JoinMiter);

    return drw;
}

void drw_resize(Drw *drw, unsigned int w, unsigned int h)
{
    if (!drw)
        return;

    drw->w = w;
    drw->h = h;
    if (drw->drawable)
        XFreePixmap(drw->dpy, drw->drawable);
    drw->drawable = XCreatePixmap(drw->dpy, drw->root, w, h, DefaultDepth(drw->dpy, drw->screen));
}

void drw_free(Drw *drw)
{
    XFreePixmap(drw->dpy, drw->drawable);
    XFreeGC(drw->dpy, drw->gc);
    drw_fontset_free(drw->fonts);
    free(drw);
}

/* This function is an implementation detail. Library users should use
 * drw_fontset_create instead.
 */
static Fnt *
xfont_create(Drw *drw, const char *fontname, FcPattern *fontpattern)
{
    Fnt *font;
    XftFont *xfont = NULL;
    FcPattern *pattern = NULL;

    if (fontname)
    {
        /* Using the pattern found at font->xfont->pattern does not yield the
         * same substitution results as using the pattern returned by
         * FcNameParse; using the latter results in the desired fallback
         * behaviour whereas the former just results in missing-character
         * rectangles being drawn, at least with some fonts. */
        if (!(xfont = XftFontOpenName(drw->dpy, drw->screen, fontname)))
        {
            fprintf(stderr, "error, cannot load font from name: '%s'\n", fontname);
            return NULL;
        }
        if (!(pattern = FcNameParse((FcChar8 *)fontname)))
        {
            fprintf(stderr, "error, cannot parse font name to pattern: '%s'\n", fontname);
            XftFontClose(drw->dpy, xfont);
            return NULL;
        }
    }
    else if (fontpattern)
    {
        if (!(xfont = XftFontOpenPattern(drw->dpy, fontpattern)))
        {
            fprintf(stderr, "error, cannot load font from pattern.\n");
            return NULL;
        }
    }
    else
    {
        die("no font specified.");
    }

    font = ecalloc(1, sizeof(Fnt));
    font->xfont = xfont;
    font->pattern = pattern;
    font->h = xfont->ascent + xfont->descent;
    font->dpy = drw->dpy;

    return font;
}

static void
xfont_free(Fnt *font)
{
    if (!font)
        return;
    if (font->pattern)
        FcPatternDestroy(font->pattern);
    XftFontClose(font->dpy, font->xfont);
    free(font);
}

Fnt *drw_fontset_create(Drw *drw, const char *fonts[], size_t fontcount)
{
    Fnt *cur, *ret = NULL;
    size_t i;

    if (!drw || !fonts)
        return NULL;

    for (i = 1; i <= fontcount; i++)
    {
        if ((cur = xfont_create(drw, fonts[fontcount - i], NULL)))
        {
            cur->next = ret;
            ret = cur;
        }
    }
    return (drw->fonts = ret);
}

void drw_fontset_free(Fnt *font)
{
    if (font)
    {
        drw_fontset_free(font->next);
        xfont_free(font);
    }
}

void drw_clr_create(Drw *drw, Clr *dest, const char *clrname)
{
    if (!drw || !dest || !clrname)
        return;

    if (!XftColorAllocName(drw->dpy, DefaultVisual(drw->dpy, drw->screen),
                           DefaultColormap(drw->dpy, drw->screen),
                           clrname, dest))
        die("error, cannot allocate color '%s'", clrname);
}

/* Wrapper to create color schemes. The caller has to call free(3) on the
 * returned color scheme when done using it. */
Clr *drw_scm_create(Drw *drw, const char *clrnames[], size_t clrcount)
{
    size_t i;
    Clr *ret;

    /* need at least two colors for a scheme */
    if (!drw || !clrnames || clrcount < 2 || !(ret = ecalloc(clrcount, sizeof(XftColor))))
        return NULL;

    for (i = 0; i < clrcount; i++)
        drw_clr_create(drw, &ret[i], clrnames[i]);
    return ret;
}

void drw_setfontset(Drw *drw, Fnt *set)
{
    if (drw)
        drw->fonts = set;
}

void drw_setscheme(Drw *drw, Clr *scm)
{
    if (drw)
        drw->scheme = scm;
}

void drw_rect(Drw *drw, int x, int y, unsigned int w, unsigned int h, int filled, int invert)
{
    if (!drw || !drw->scheme)
        return;
    XSetForeground(drw->dpy, drw->gc, invert ? drw->scheme[ColBg].pixel : drw->scheme[ColFg].pixel);
    if (filled)
        XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
    else
        XDrawRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w - 1, h - 1);
}

int drw_text(Drw *drw, int x, int y, unsigned int w, unsigned int h, unsigned int lpad, const char *text, int invert)
{
    int ty, ellipsis_x = 0;
    unsigned int tmpw, ew, ellipsis_w = 0, ellipsis_len, hash, h0, h1;
    XftDraw *d = NULL;
    Fnt *usedfont, *curfont, *nextfont;
    int utf8strlen, utf8charlen, utf8err, render = x || y || w || h;
    long utf8codepoint = 0;
    const char *utf8str;
    FcCharSet *fccharset;
    FcPattern *fcpattern;
    FcPattern *match;
    XftResult result;
    int charexists = 0, overflow = 0;
    /* keep track of a couple codepoints for which we have no match. */
    static unsigned int nomatches[128], ellipsis_width, invalid_width;
    static const char invalid[] = "�";

    if (!drw || (render && (!drw->scheme || !w)) || !text || !drw->fonts)
        return 0;

    if (!render)
    {
        w = invert ? invert : ~invert;
    }
    else
    {
        XSetForeground(drw->dpy, drw->gc, drw->scheme[invert ? ColFg : ColBg].pixel);
        XFillRectangle(drw->dpy, drw->drawable, drw->gc, x, y, w, h);
        if (w < lpad)
            return x + w;
        d = XftDrawCreate(drw->dpy, drw->drawable,
                          DefaultVisual(drw->dpy, drw->screen),
                          DefaultColormap(drw->dpy, drw->screen));
        x += lpad;
        w -= lpad;
    }

    usedfont = drw->fonts;
    if (!ellipsis_width && render)
        ellipsis_width = drw_fontset_getwidth(drw, "...");
    if (!invalid_width && render)
        invalid_width = drw_fontset_getwidth(drw, invalid);
    while (1)
    {
        ew = ellipsis_len = utf8err = utf8charlen = utf8strlen = 0;
        utf8str = text;
        nextfont = NULL;
        while (*text)
        {
            utf8charlen = utf8decode(text, &utf8codepoint, &utf8err);
            for (curfont = drw->fonts; curfont; curfont = curfont->next)
            {
                charexists = charexists || XftCharExists(drw->dpy, curfont->xfont, utf8codepoint);
                if (charexists)
                {
                    drw_font_getexts(curfont, text, utf8charlen, &tmpw, NULL);
                    if (ew + ellipsis_width <= w)
                    {
                        /* keep track where the ellipsis still fits */
                        ellipsis_x = x + ew;
                        ellipsis_w = w - ew;
                        ellipsis_len = utf8strlen;
                    }

                    if (ew + tmpw > w)
                    {
                        overflow = 1;
                        /* called from drw_fontset_getwidth_clamp():
                         * it wants the width AFTER the overflow
                         */
                        if (!render)
                            x += tmpw;
                        else
                            utf8strlen = ellipsis_len;
                    }
                    else if (curfont == usedfont)
                    {
                        text += utf8charlen;
                        utf8strlen += utf8err ? 0 : utf8charlen;
                        ew += utf8err ? 0 : tmpw;
                    }
                    else
                    {
                        nextfont = curfont;
                    }
                    break;
                }
            }

            if (overflow || !charexists || nextfont || utf8err)
                break;
            else
                charexists = 0;
        }

        if (utf8strlen)
        {
            if (render)
            {
                ty = y + (h - usedfont->h) / 2 + usedfont->xfont->ascent;
                XftDrawStringUtf8(d, &drw->scheme[invert ? ColBg : ColFg],
                                  usedfont->xfont, x, ty, (XftChar8 *)utf8str, utf8strlen);
            }
            x += ew;
            w -= ew;
        }
        if (utf8err && (!render || invalid_width < w))
        {
            if (render)
                drw_text(drw, x, y, w, h, 0, invalid, invert);
            x += invalid_width;
            w -= invalid_width;
        }
        if (render && overflow)
            drw_text(drw, ellipsis_x, y, ellipsis_w, h, 0, "...", invert);

        if (!*text || overflow)
        {
            break;
        }
        else if (nextfont)
        {
            charexists = 0;
            usedfont = nextfont;
        }
        else
        {
            /* Regardless of whether or not a fallback font is found, the
             * character must be drawn. */
            charexists = 1;

            hash = (unsigned int)utf8codepoint;
            hash = ((hash >> 16) ^ hash) * 0x21F0AAAD;
            hash = ((hash >> 15) ^ hash) * 0xD35A2D97;
            h0 = ((hash >> 15) ^ hash) % LENGTH(nomatches);
            h1 = (hash >> 17) % LENGTH(nomatches);
            /* avoid expensive XftFontMatch call when we know we won't find a match */
            if (nomatches[h0] == utf8codepoint || nomatches[h1] == utf8codepoint)
                goto no_match;

            fccharset = FcCharSetCreate();
            FcCharSetAddChar(fccharset, utf8codepoint);

            if (!drw->fonts->pattern)
            {
                /* Refer to the comment in xfont_create for more information. */
                die("the first font in the cache must be loaded from a font string.");
            }

            fcpattern = FcPatternDuplicate(drw->fonts->pattern);
            FcPatternAddCharSet(fcpattern, FC_CHARSET, fccharset);
            FcPatternAddBool(fcpattern, FC_SCALABLE, FcTrue);

            FcConfigSubstitute(NULL, fcpattern, FcMatchPattern);
            FcDefaultSubstitute(fcpattern);
            match = XftFontMatch(drw->dpy, drw->screen, fcpattern, &result);

            FcCharSetDestroy(fccharset);
            FcPatternDestroy(fcpattern);

            if (match)
            {
                usedfont = xfont_create(drw, NULL, match);
                if (usedfont && XftCharExists(drw->dpy, usedfont->xfont, utf8codepoint))
                {
                    for (curfont = drw->fonts; curfont->next; curfont = curfont->next)
                        ; /* NOP */
                    curfont->next = usedfont;
                }
                else
                {
                    xfont_free(usedfont);
                    nomatches[nomatches[h0] ? h1 : h0] = utf8codepoint;
                no_match:
                    usedfont = drw->fonts;
                }
            }
        }
    }
    if (d)
        XftDrawDestroy(d);

    return x + (render ? w : 0);
}

void drw_map(Drw *drw, Window win, int x, int y, unsigned int w, unsigned int h)
{
    if (!drw)
        return;

    XCopyArea(drw->dpy, drw->drawable, win, drw->gc, x, y, w, h, x, y);
    XSync(drw->dpy, False);
}

unsigned int
drw_fontset_getwidth(Drw *drw, const char *text)
{
    if (!drw || !drw->fonts || !text)
        return 0;
    return drw_text(drw, 0, 0, 0, 0, 0, text, 0);
}

unsigned int
drw_fontset_getwidth_clamp(Drw *drw, const char *text, unsigned int n)
{
    unsigned int tmp = 0;
    if (drw && drw->fonts && text && n)
        tmp = drw_text(drw, 0, 0, 0, 0, 0, text, n);
    return MIN(n, tmp);
}

void drw_font_getexts(Fnt *font, const char *text, unsigned int len, unsigned int *w, unsigned int *h)
{
    XGlyphInfo ext;

    if (!font || !text)
        return;

    XftTextExtentsUtf8(font->dpy, font->xfont, (XftChar8 *)text, len, &ext);
    if (w)
        *w = ext.xOff;
    if (h)
        *h = font->h;
}

Cur *drw_cur_create(Drw *drw, int shape)
{
    Cur *cur;

    if (!drw || !(cur = ecalloc(1, sizeof(Cur))))
        return NULL;

    cur->cursor = XCreateFontCursor(drw->dpy, shape);

    return cur;
}

void drw_cur_free(Drw *drw, Cur *cursor)
{
    if (!cursor)
        return;

    XFreeCursor(drw->dpy, cursor->cursor);
    free(cursor);
}
